home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / WINDOWS / CLIPST.ARJ / ARRAYMGR.H next >
C/C++ Source or Header  |  1992-03-16  |  4KB  |  143 lines
  1. // arraymgr.h
  2.  
  3. #if !defined(ARRAYMGR_H)
  4. #define ARRAYMGR_H
  5.  
  6. #include<windows.h>
  7. #include<memory.h>
  8.  
  9. typedef struct _clipelement
  10.     {
  11.     DWORD offset;
  12.     WORD format;
  13.     DWORD size;
  14.     WORD usage;
  15.     } CLIPELEMENT;
  16.  
  17. class ArrayMgr
  18.     {
  19.     int numElements;
  20.     int maxElements;
  21.     CLIPELEMENT *array;
  22.     LONG lastoffset;
  23.  
  24.     void DecrementUsage(DWORD offset);
  25.     void SetUsage(DWORD offset, WORD usage);
  26.  
  27. public:
  28.     void Init(int Els)
  29.         {
  30.         maxElements = Els;
  31.         array = (CLIPELEMENT *)new char[Size()];
  32.         memset(array,0,Size());
  33.         numElements = 0;
  34.         lastoffset = 0L;
  35.         }
  36.     ArrayMgr(void)
  37.         {
  38.         numElements = maxElements = 0;
  39.         array = NULL;
  40.         }
  41.  
  42.     ArrayMgr(int Els)
  43.         {
  44.         Init(Els);
  45.         }
  46.     ~ArrayMgr(void)
  47.         {
  48.         delete array;
  49.         }
  50.     BOOL IsValid(int index)
  51.         {
  52.         if(index >= 0 && index < numElements)
  53.             return TRUE;
  54.         return FALSE;
  55.         }
  56.     CLIPELEMENT *operator[](int index)
  57.         {                    
  58.         if(index >= 0 && index < maxElements)   // use maxElements not IsValid
  59.             return (CLIPELEMENT *)&array[index];
  60.         return (CLIPELEMENT *)NULL;
  61.         }
  62.     int NumElements(void)       {   return numElements; }
  63.     int MaxElements(void)       {   return maxElements; }
  64.     int Size(void)              {   return maxElements*sizeof(CLIPELEMENT); }
  65.     void SetNumElements(int n)  {   numElements = n;    }
  66.     void SetMaxElements(int n)  {   maxElements = n;    }
  67.     void *Array(void)           {   return (void *)array;   }
  68.     BOOL ReSize(int newMaxEls)
  69.         {
  70.         if(newMaxEls == maxElements)
  71.             return TRUE;
  72.         if(newMaxEls < maxElements)
  73.             {
  74.             maxElements = newMaxEls;
  75.             if(maxElements < numElements)
  76.                 numElements = maxElements;
  77.             return TRUE;
  78.             }
  79.  
  80.         int size;
  81.         CLIPELEMENT *temp = 
  82.             (CLIPELEMENT *)new char[size = (newMaxEls*sizeof(CLIPELEMENT))];
  83.         if(!temp)
  84.             return FALSE;
  85.         memset(temp,0,size);
  86.         memcpy(temp,array,Size());
  87.         delete array;
  88.         array = temp;
  89.         maxElements = newMaxEls;
  90.         return TRUE;
  91.         }
  92.  
  93.     void Add(int index, DWORD off, WORD fmt, DWORD sz, WORD us = 0)
  94.         {
  95.         array[index].offset = off;
  96.         array[index].format = fmt;
  97.         array[index].size = sz;
  98.         array[index].usage = us;
  99.         numElements++;
  100.         }
  101.     void Insert(DWORD off, WORD fmt, DWORD sz, WORD us = 0)
  102.         {                       // shift array down
  103.         if(numElements > 0)     // if nothing there, don't bother
  104.             memmove(&array[1],&array[0],Size()-sizeof(CLIPELEMENT));
  105.         if((numElements == maxElements) && (numElements > 0))
  106.              numElements--;     // decrement numElements 
  107.         Add(0,off,fmt,sz);      // add new element
  108.         if(us)                  // if usage > 0, update all owners' usage
  109.             SetUsage(off,us);
  110.         }
  111.     void Delete(int index)
  112.         {
  113.         if(numElements > 0)
  114.             {
  115.             if(array[index].usage)          // if block in use elsewhere
  116.                 DecrementUsage(array[index].offset);    // usage-- for owners
  117.                 // close array up over deleted one
  118.             memmove(&array[index],&array[index+1],
  119.                 (maxElements-(index+1))*sizeof(CLIPELEMENT));
  120.                 // reduce number of elements
  121.             numElements--;
  122.             }
  123.         }
  124.     DWORD LastOffset(LONG lo = 0L)
  125.         {
  126.         if(!numElements)
  127.             return 0L;
  128.         if(lo > 0L)
  129.             lastoffset = lo;
  130.         return lastoffset;
  131.     //    return (array[0].offset+array[0].size +
  132.     //        (array[0].format == CF_BITMAP ? sizeof(BITMAP) : 0L));
  133.         }
  134.  
  135.     BOOL IsDupe(int index);
  136.     void UpdateOffsets(DWORD offset);
  137.     void UpdateDupes(int index, DWORD newoffset);
  138.     BOOL IsFirstDupe(int index);
  139.     };
  140.  
  141. #endif
  142.  
  143.